#!/usr/bin/env python3

import os
import shlex
import sys
import signal
import subprocess

import common

defaults = {
    'after': '',
    'before': '',
    'break_at': None,
    'kgdb': False,
    'no_continue': False,
    'no_lxsymbols': False,
    'sim': False,
    'userland': None,
}

def main(args, extra_args=None):
    '''
    :param args: argparse parse_argument() output. Must contain all the common options,
                 but does not need GDB specific ones.
    :type args: argparse.Namespace

    :param extra_args: extra arguments to be added to args
    :type extra_args: Dict[str,Any]

    :return: GDB exit status
    :rtype: int
    '''
    global defaults
    args = common.resolve_args(defaults, args, extra_args)
    after = shlex.split(args.after)
    before = shlex.split(args.before)
    if args.break_at is not None:
        break_at = ['-ex', 'break {}'.format(args.break_at)]
    else:
        break_at = []
    linux_full_system = (args.baremetal is None and args.userland is None)
    if args.userland:
        image = common.resolve_userland(args.userland)
    elif args.baremetal:
        image = args.baremetal
    else:
        image = common.vmlinux
    if args.baremetal:
        allowed_toolchains = ['crosstool-ng', 'buildroot', 'host']
    else:
        allowed_toolchains = ['buildroot', 'crosstool-ng', 'host']
    cmd = (
        [common.get_toolchain_tool('gdb', allowed_toolchains=allowed_toolchains)] +
        before +
        ['-q']
    )
    if linux_full_system:
        cmd.extend(['-ex', 'add-auto-load-safe-path {}'.format(common.linux_build_dir)])
    if args.sim:
        target = 'sim'
    else:
        if args.kgdb:
            port = common.extra_serial_port
        else:
            port = common.gdb_port
        target = 'remote localhost:{}'.format(port)
    cmd.extend([
        '-ex', 'file {}'.format(image),
        '-ex', 'target {}'.format(target),
    ])
    if not args.kgdb:
        cmd.extend(break_at)
    if not args.no_continue:
        # ## lx-symbols
        #
        # ### lx-symbols after continue
        #
        # lx symbols must be run after continue.
        #
        # running it immediately after the connect on the bootloader leads to failure,
        # likely because kernel structure on which it depends are not yet available.
        #
        # With this setup, continue runs, and lx-symbols only runs when a break happens,
        # either by hitting the breakpoint, or by entering Ctrl + C.
        #
        # Sure, if the user sets a break on a raw address of the bootloader,
        # problems will still arise, but let's think about that some other time.
        #
        # ### lx-symbols autoload
        #
        # The lx-symbols commands gets loaded through the file vmlinux-gdb.py
        # which gets put on the kernel build root when python debugging scripts are enabled.
        cmd.extend(['-ex', 'continue'])
        if not args.no_lxsymbols and linux_full_system:
            cmd.extend(['-ex', 'lx-symbols {}'.format(common.kernel_modules_build_subdir)])
    cmd.extend(after)
    # I would rather have cwd be out_rootfs_overlay_dir,
    # but then lx-symbols cannot fine the vmlinux and fails with:
    # vmlinux: No such file or directory.
    return common.run_cmd(
        cmd,
        cmd_file=os.path.join(common.run_dir, 'run-gdb.sh'),
        cwd=common.linux_build_dir
    )

if __name__ == '__main__':
    parser = common.get_argparse(argparse_args={'description': 'Connect with GDB to an emulator to debug Linux itself'})
    parser.add_argument(
        '-A', '--after', default=defaults['after'],
        help='Pass extra arguments to GDB, to be appended after all other arguments'
    )
    parser.add_argument(
        '--before', default=defaults['before'],
        help='Pass extra arguments to GDB to be prepended before any of the arguments passed by this script'
    )
    parser.add_argument(
        '-C', '--no-continue', default=defaults['no_continue'], action='store_true',
        help="Don't run continue after connecting"
    )
    parser.add_argument(
        '-k', '--kgdb', default=defaults['kgdb'], action='store_true'
    )
    parser.add_argument(
        '--sim', default=defaults['sim'], action='store_true',
        help='''Use the built-in GDB CPU simulator
See: https://github.com/cirosantilli/linux-kernel-module-cheat#gdb-builtin-cpu-simulator
'''
    )
    parser.add_argument(
        '-X', '--no-lxsymbols', default=defaults['no_lxsymbols'], action='store_true'
    )
    parser.add_argument(
        '--userland', default=defaults['userland'],
    )
    parser.add_argument(
        'break_at', nargs='?',
        help='Extra options to append at the end of the emulator command line'
    )
    args = common.setup(parser)
    sys.exit(main(args))
